home *** CD-ROM | disk | FTP | other *** search
/ Graphics Plus / Graphics Plus.iso / general / procssng / ccs / ccs-11tl.lha / lbl / hips / sources / 3d-tools / 3drotate90.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-09-22  |  7.6 KB  |  266 lines
  1. /*
  2. @ 3DROTATE90 - rotate 3D image into another 3D image for displaying and looking
  3. @    the different surface of the image.
  4. @
  5. @    -l (look from left side) slices vertically (y-z surface, parallel to Y
  6. @        axle). It works exactly same as in 3drotate.
  7. @    -L horizontally rotate90 to left. NO keep U-L corner.
  8. @    -t(top) specify slicing horizontally (x-z surface, parallel to X axle).
  9. @        this option is similar to in 3drotate but slower.
  10. @ After using 3DROTATE90 twice in same direction will get same result as
  11. @    using 3DROTATE90 once in the other direction. So 3drotate90 only can
  12. @    let people to see the front, left and top. For other 3 directions. use
  13. @    3DROTATE180 goto the back first and then use 3drotate90 to see the
  14. @    right (left to back) and bottom (top to back).
  15. @    -L will help to see different direction.
  16. @
  17. %    Copyright (c)    1991    Jin, Guojun
  18. */
  19. char    usage[]="options\n\
  20. -l    rotate to left with upper-left corner no changed\n\
  21. -L    rotate to left horizontally\n\
  22. -t    rotate to top with U-P-C no changed\n\
  23. -c #    starting column for -l or -L\n\
  24. -r #    starting row for -t\n\
  25. -n #    number of frames will output\n\
  26. [<] input [> -o output]\n";
  27. /*
  28. @ Improtant Note:
  29. @    MUST include <math.h> in this file
  30. @
  31. @ AUTHOR:    Jin Guojun - LBL    2/1/91
  32. */
  33.  
  34. #include "header.def"
  35. #include "imagedef.h"
  36. #include <math.h>
  37.  
  38. U_IMAGE    uimg;
  39. bool    slice_dir, t2f;
  40.  
  41. #define    ibuf    uimg.src
  42. #define    obuf    uimg.dest
  43. #define    tbuf    uimg.cnvt
  44. #define    p_size    uimg.pxl_in
  45. #define    o_size    uimg.pxl_out
  46. #define    img_w    uimg.width
  47. #define    img_h    uimg.height
  48.  
  49. #define    GValue()    arget(argc, argv, &i, &c);
  50. #define    F2T    if (t2f) ilc_transfer(obuf, obuf, fsizeNew, 4, 0, o_size=3)
  51.  
  52.  
  53. main(argc, argv)
  54. int    argc;
  55. char**    argv;
  56. {
  57. /*  !!!    input number is start from 1 and convert to from 0. See line 110 */
  58. int    bgn_cln=1, bgn_row=uimg.color_dpy=1, frmsNew=0;
  59. MType    i, f, r, c,
  60.     fsizeNew, fsize;
  61.  
  62. format_init(&uimg, IMAGE_INIT_TYPE, HIPS, HIPS, *argv, "S20-2");
  63.  
  64. for (i=1; i<argc; i++)
  65.     if (*argv[i] == '-') {
  66.     c = 1;
  67.     switch (argv[i][c++])    {
  68.     case 'c':
  69.         bgn_cln = GValue();    break;
  70.     case 'r':
  71.         bgn_row = GValue();    break;
  72.     case 'L':
  73.     case 'l':
  74.     case 't':
  75.         slice_dir = argv[i][1];    break;
  76.     case 'n':
  77.         frmsNew = GValue();    break;
  78.     case 'o':
  79.         if (avset(argc, argv, &i, &c, 1) &&
  80.             (out_fp=freopen(argv[i]+c, "wb", stdout)))    break;
  81.         msg("%s can't be opened for write", argv[i]+c);
  82.     default:
  83. errout:        usage_n_options(usage, i, argv[i]);
  84.     }
  85. }
  86. else if ((in_fp=freopen(argv[i], "rb", stdin)) == NULL)
  87.     syserr("input file %s not found", argv[i]);
  88.  
  89. io_test(fileno(in_fp), goto    errout);
  90.  
  91. (*uimg.header_handle)(HEADER_READ, &uimg, 0, 0);
  92. (*uimg.header_handle)(HEADER_TRANSF, &uimg, 0);
  93. if (uimg.color_form == CFM_SEPLANE)
  94.     uimg.color_form = CFM_ILC;
  95. t2f = uimg.color_form == CFM_ILC;
  96. fsize = img_w * img_h;
  97.  
  98. if (bgn_row > img_h)    bgn_row = img_h;
  99. if (bgn_cln > img_w)    bgn_cln = img_w;
  100. if (bgn_cln)    bgn_cln--;
  101. if (bgn_row)    bgn_row--;
  102.  
  103. ibuf = nzalloc(p_size, fsize*uimg.frames, "ibuf");
  104. uimg.load_all = uimg.frames;
  105. (*uimg.std_swif)(FI_LOAD_FILE, &uimg, 0, No);
  106. if (t2f)    {
  107.     tbuf = nzalloc(p_size=4, fsize*uimg.frames, "tbuf");
  108.     ilc_transfer(tbuf, ibuf, fsize*uimg.frames, 3, 0, 4);
  109.     free(ibuf);    ibuf = tbuf;
  110. }
  111.  
  112. switch(slice_dir)
  113. {
  114. case 't':    /*    look from top    */
  115. default:
  116.     if (!frmsNew || frmsNew > img_h-bgn_row)
  117.         frmsNew = img_h - bgn_row;
  118.     i = img_h = img_w;    img_w = uimg.frames;
  119.     uimg.frames = frmsNew;    frmsNew += bgn_row;
  120.     fsizeNew = img_w * img_h;
  121.     obuf = nzalloc(p_size, fsizeNew, "tbuf");
  122.     {
  123.     char    mesgbuf[1024];
  124.     sprintf(mesgbuf,
  125.     "horizontal slicing at row%d (%d frames). Rotate forward & turn right\n",
  126.         bgn_row+1, uimg.frames);
  127.     msg("%s", mesgbuf);
  128.     (*uimg.header_handle)(ADD_DESC, &uimg, mesgbuf);
  129.     }
  130.     (*uimg.header_handle)(HEADER_WRITE, &uimg, argc, argv, True);
  131.  
  132.     switch(p_size)    {
  133.     case 1:    {
  134.     register byte    *inbp, *obp, *itmp, *otmp;
  135.         for (r=bgn_row; r<frmsNew; r++){
  136.         inbp = itmp = (byte*)ibuf + r*i;
  137.         obp = otmp = obuf;
  138.         for (f=0; f < img_w; f++, inbp=itmp+=fsize, obp=otmp+f)
  139.             for (c=0; c < img_h; c++, obp+=img_w)
  140.             *obp = *inbp++;
  141.         if (fwrite(obuf, o_size, fsizeNew, out_fp) != fsizeNew)
  142.             syserr("error during h write.");
  143.         }
  144.     }break;
  145.     case 2:    {
  146.     register short    *inbp, *obp, *itmp, *otmp;
  147.         for (r=bgn_row; r<frmsNew; r++){
  148.         inbp = itmp = (short*)ibuf + r*i;
  149.         obp = otmp = obuf;
  150.         for (f=0; f < img_w; f++, inbp=itmp+=fsize, obp=otmp+f)
  151.             for (c=0; c < img_h; c++, obp += img_w)
  152.             *obp = *inbp++;
  153.         if (fwrite(obuf, o_size, fsizeNew, out_fp) != fsizeNew)
  154.             syserr("error during h write.");
  155.         }
  156.     }break;
  157.     case 4:    {
  158.     register long    *inbp, *obp, *itmp, *otmp;
  159.         for (r=bgn_row; r<frmsNew; r++){
  160.         inbp = itmp = (long*)ibuf + r*i;
  161.         otmp = obuf;
  162.         for (f=0; f < img_w; f++, inbp=itmp+=fsize)
  163.             for (c=0, obp=otmp+f; c<img_h; c++, obp+=img_w)
  164.             *obp = *inbp++;
  165.         F2T;
  166.         if (fwrite(obuf, o_size, fsizeNew, out_fp) !=
  167.            fsizeNew)    syserr("error during h write.");
  168.         }
  169.     }
  170.     }    /* end of switch(p_size)    */
  171.     break;
  172. case 'l':    /*    look from left side.    */
  173.     if (!frmsNew || frmsNew > img_w-bgn_cln)
  174.         frmsNew = img_w - bgn_cln;
  175.     i = img_w;    img_w = img_h;
  176.     img_h = uimg.frames;    uimg.frames = frmsNew;
  177.     fsizeNew = img_w * img_h;
  178.     obuf = nzalloc(p_size, fsizeNew, "lbuf");
  179.     {
  180.     char    mesgbuf[1024];
  181.     sprintf(mesgbuf,
  182.     "vertical slicing at column%d (%d frames). Rotate to left & turn left\n",
  183.         bgn_cln+1, frmsNew);
  184.     msg("%s", mesgbuf);
  185.     (*uimg.header_handle)(ADD_DESC, &uimg, mesgbuf);
  186.     }
  187.     (*uimg.header_handle)(HEADER_WRITE, &uimg, argc, argv, True);
  188.  
  189.     for (c=bgn_cln; c<frmsNew; c++){
  190.     switch(p_size){
  191.     case 1:    {
  192.     register byte    *inbp, *tmpp=ibuf, *obp=obuf;
  193.         for (f=0, tmpp+=c; f < img_h; f++, tmpp+=fsize)
  194.             for (r=0, inbp=tmpp; r<img_w; r++, inbp+=i)/* old_cln */
  195.             *obp++ = *inbp;
  196.         }break;
  197.     case 2:    {
  198.     register short    *inbp, *tmpp=ibuf, *obp=obuf;
  199.         for (f=0, tmpp+=c; f < img_h; f++, tmpp+=fsize)
  200.             for (r=0, inbp=tmpp; r<img_w; r++, inbp+=i)/* old_cln */
  201.             *obp++ = *inbp;
  202.     }break;
  203.     case 4:    {
  204.     register long    *inbp, *tmpp=ibuf, *obp=obuf;
  205.         for (f=0, tmpp+=c; f < img_h; f++, tmpp+=fsize)
  206.             for (r=0, inbp=tmpp; r<img_w; r++, inbp+=i)/* old_cln */
  207.             *obp++ = *inbp;
  208.         }
  209.         F2T;
  210.     }    /* end switch    */
  211.     if (fwrite(obuf, o_size, fsizeNew, out_fp) != fsizeNew)
  212.         syserr("error during v write.");
  213.     }    /* end of for    */
  214.     break;
  215. case 'L':    /*    look from left side.    Y-Z => xyz = 'z'    */
  216.     if (!frmsNew || frmsNew > img_w-bgn_cln)
  217.     frmsNew = img_w - bgn_cln;
  218.     i = img_w;    img_w = uimg.frames;    uimg.frames = frmsNew;
  219.     fsizeNew = img_w * img_h;
  220.     obuf = zalloc(p_size, fsizeNew, "vbuf");
  221.  
  222.     {
  223.     char    mesgbuf[1024];
  224.     sprintf(mesgbuf,
  225.     "vertical slicing at column%d (%d frames). Rotate to left horizontally\n",
  226.         bgn_cln+1, frmsNew);
  227.     msg("%s", mesgbuf);
  228.     (*uimg.header_handle)(ADD_DESC, &uimg, mesgbuf);
  229.     }
  230.     (*uimg.header_handle)(HEADER_WRITE, &uimg, argc, argv, True);
  231.  
  232.     for (c=bgn_cln; c<frmsNew; c++){
  233.     switch(p_size) {
  234.     case 1:    {
  235.     register byte    *inbp, *itmp, *obp, *otmp;
  236.         itmp = (byte*)ibuf + c + fsize*(img_w-1);
  237.         obp = otmp = obuf;
  238.         for (f=0; f < img_w; f++, itmp-=fsize, obp=otmp+f)
  239.             for (inbp=itmp, r=img_h; r--; inbp+=i, obp+=img_w)
  240.             *obp = *inbp;
  241.     }break;
  242.     case 2:    {
  243.     register short    *inbp, *itmp, *obp, *otmp;
  244.         itmp = (short*)ibuf + c + fsize*(img_w-1);
  245.         obp = otmp = obuf;
  246.         for (f=0; f < img_w; f++, itmp-=fsize, obp=otmp+f)
  247.             for (r=img_h, inbp=itmp; r--; inbp+=i, obp+=img_w)
  248.             *obp = *inbp;
  249.     }break;
  250.     case 4:    {
  251.     register long    *inbp, *itmp, *obp, *otmp;
  252.         itmp = (long*)ibuf + c + fsize*(img_w-1);
  253.         obp = otmp = obuf;
  254.         for (f=0; f < img_w; f++, itmp-=fsize, obp=otmp+f)
  255.             for (r=img_h, inbp=itmp; r--; inbp+=i, obp+=img_w)
  256.             *obp = *inbp;
  257.     }
  258.         F2T;
  259.     }    /* end of switch (p_size)    */
  260.     if (fwrite(obuf, o_size, fsizeNew, out_fp) != fsizeNew)
  261.         syserr("error during L write.");
  262.     }    /* end of for img_w    */
  263. }    /* end of switch(dir)    */
  264. return    0;
  265. }
  266.